% Declaration des faits dynamiques
:- dynamic(plateau/1).
:- dynamic(joueur1/1). % [S(x,y)][r(x,y)][r(x,y)][r(x,y)][r(x,y)]
:- dynamic(joueur2/1).

% Predicats

% concat(List1, List2, Concat_List1_List2):
%   Concat_List1_List2 is the concatenation of List1 & List2
concat([], List2, List2).
concat(List1, [], List1).
concat([Item | Tail1], List2, [Item | Concat_Tail1_List2]) :-
      concat(Tail1, List2, Concat_Tail1_List2).

%- enlever_doublons(l, m) enleve tous les elements redondants de l et met le resultat dans m -%
enlever_doublons([], []).
enlever_doublons([X|L], [X|M]):-
	hors_de(X, L),
	enlever_doublons(L, M).
enlever_doublons([_|L], M):-
	enlever_doublons(L, M).

hors_de(_, []).
hors_de(X, [Y|L]):-
	X \== Y,
	hors_de(X, L).

orientationplateau(1, 	[
				[2, 2, 3, 1, 2, 2],
				[1, 3, 1, 3, 1, 3],
				[3, 1, 2, 2, 3, 1],
				[2, 3, 1, 3, 1, 2],
				[2, 1, 3, 1, 3, 2],
				[1, 3, 2, 2, 1, 3]
			]
).

orientationplateau(2, 	[
				[1, 2, 2, 3, 1, 2],
				[3, 1, 3, 1, 3, 2],
				[2, 3, 1, 2, 1, 3],
				[2, 1, 3, 2, 3, 1],
				[1, 3, 1, 3, 1, 2],
				[3, 1, 2, 1, 3, 1]
			]
).

orientationplateau(3, 	[
				[3, 1, 2, 2, 3, 1],
				[2, 3, 1, 3, 1, 2],
				[2, 1, 3, 1, 3, 2],
				[1, 3, 2, 2, 1, 3],
				[3, 1, 3, 1, 3, 2],
				[2, 2, 1, 3, 2, 2]
			]
).

orientationplateau(4, 	[
				[2, 3, 1, 2, 2, 3],
				[2, 1, 3, 1, 3, 1],
				[1, 3, 2, 3, 1, 2],
				[3, 1, 2, 1, 3, 2],
				[2, 3, 1, 3, 1, 3],
				[2, 2, 3, 2, 2, 1]
			]
).

choixorientation(Numorientation) :- orientationplateau(Numorientation,P), asserta(plateau(P)).


%checkpion([],_,_,Z) :- Z=0.
%checkpion([T|Q],X,Y,Z) :- checkcoor(T, X, Y) . %veridier si on est sur la premiere case ou les autres

%checkcoor([T], X, Y) :- T=Y
%checkcoor([T|Q], X,Y) :- T=X

%checkpion(J, X, Y, V):-


%afficheplateau(P) : input plateau

affiche :- plateau(P), afficheplateau(P,0).

afficheplateau([],_).
afficheplateau([T|Q],N) :- write('|---------------|'), nl, afficheLigne(T,N), N2 is N-1 ,afficheplateau(Q,N2),!.


%affiche les valeurs de ligne puis demande l'affichage des joueurs par case
afficheLigne([],N) :- write('|'), nl, afficheligne2(N,0).
afficheLigne([T|Q],_) :- write('|'), write(T), write(' '), nl,  afficheLigne(Q),!.

%affichage des joueurs par case
%afficheligne2(N,Y) :- .

%joueur(X,Y,J1,Z) retourne le joueur et le pion de la case X Y
%%joueur(X,Y,J,Z):- 

%%joueur([[X|Y]|Q],X,Y) :- 




%retourne la valeur de la case
valeur([[U|V]|_], 1, Y, Z) :- Y \== 1 , valeur([U|V], 1, Y, Z),!.
valeur([T|_], 1 , 1 , Z) :- Z=T,!.
valeur([_|Q], 1, Y, Z) :- Y2 is Y-1, valeur(Q, 1, Y2, Z),!.
valeur([_|Q], X, Y, Z) :- X2 is X-1, valeur(Q, X2, Y, Z).

valeur_test(X,Y,R) :-
	plateau(P),
	valeur(P,X,Y,R).
%coups possibles

% coups 
% coordonnee1 coordonnee2 valeur coups-interdit retour 
% Depart : coups interdit = coord1 coord2

coups(0,_,_,_,_):-!. %definition des coups hors champs.
coups(7,_,_,_,_):-!.
coups(_,0,_,_,_):-!.
coups(_,7,_,_,_):-!.
coups(X,Y,_,[[X|Y]|_],_):-!. %coups interdit retour en arrière

coups(X,Y,0,_,R):-
	R = [[X,Y]],!. %renvoi de la valeur
	
coups(X,Y,V,[T1|T2],R):-
	Vt is V-1,
	X1 is T1-1,
	X2 is T1+1,
	Y1 is T2-1,
	Y2 is T2+1,
	L = [X,Y],
	coups(X1,Y,Vt,L,R1), %on appel les 4 cotés
	coups(X,Y1,Vt,L,R2),
	coups(X2,Y,Vt,L,R3),
	coups(X,Y2,Vt,L,R4),
	append(R1,R2,RT1),
	append(R3,R4,RT2),
	append(RT1,RT2,R).

distance([X1,Y1], [X2,Y2], R) :-
	R1 is X1 - X2,
	R2 is Y1 - Y2,
	R is abs(R1) + abs(R2).

distance_en_coups([X1,Y1], [X2,Y2], R) :- distance_en_coups_2([[X1,Y1]], [X2,Y2], 2,2, 0, R).

distance_en_coups_2(_,_, Max, _, Max, _):-!.

distance_en_coups_2([[X,Y]|_], [X,Y], _,MaxV, Val, Val):-
	Val < MaxV.

distance_en_coups_2([[X1,Y1]|Q], [X2,Y2], Maxprof, MaxVal, Val, [T|Q]):-
	plateau(P),
	valeur(P,X1,Y1,Valeur),
	coups(X1,Y1, Valeur, [X1,Y1], ListeCoups),
	Val1 is Val +1,
	%enlever_doublons([Q,ListeCoups],R),
	distance_en_coups_2(ListeCoups, [X2,Y2], Maxprof, MaxVal, Val1, T),
	distance_en_coups_2(Q, [X2,Y2], Maxprof, MaxVal, Val, Q),!.
	
	
	





























